1. Field of the Invention
The present invention relates generally to instruction set translators and more particularly to the reduction of performance degradation of an instruction set translator due to self-modifying code.
2. Description of the Related Art
An executable program that is designed to be executed by a certain processor (i.e., a source processor) may be able to be executed by a different processor (i.e., a target processor) with the aid of either an instruction set interpreter or an instruction set translator. An instruction set interpreter, (running on the target processor), fetches an instruction from the source processor code, interprets the instruction and executes the necessary code to mimic the behavior of the source processor. Then, the instruction set interpreter fetches the next instruction, interprets it and executes its equivalent and so on until a halt instruction is encountered or the user aborts the process. The instruction interpretations are not stored and thus, the instruction set interpreter fetches and interprets the source code as often as the code is encountered.
An instruction set translator, on the other hand, translates blocks of the source code and stores them for subsequent executions. The resulting set of code generated, in this instance, is referred to as a code block. The code block can potentially contain the translation of hundreds of source code instructions. After the code block translation is stored, it can be executed as often as needed, thus, eliminating subsequent translation steps. Consequently, emulation of an executable program by means of an instruction set translator is usually faster and more efficient than using an instruction set interpreter.
Nevertheless, when "self-modifying code" is embedded in a source code, the performance of an instruction set translator may be degraded to such an extent that it becomes as slow as, or slower than, an instruction set interpreter. A "self-modifying code" is a technique used by programmers to increase the processing speed of executable programs. For example, an address of a memory transfer operation in a graphics environment (i.e., the operand of the transfer instruction) may be explicitly incremented while looping through video memory. This allows the code to be executed faster since the operand of the instruction is itself being modified thus bypassing potentially several memory accesses. This technique, however, decreases the performance of the instruction set translator because at each iteration, the self-modifying code causes the instruction set translator to purge the translated code and retranslate the entire code block containing the modified instruction. Consequently, the instruction set translator will spend most of its time translating source processor code rather than executing already translated code.
Thus, there is a need in the art for an apparatus and method of isolating instructions that have been modified from those that have not such that only the translations of the modified instructions are purged and retranslated by an instruction set translator.